#
# 描述
# 兔子的数量以这样的方式增长：每个月的兔子数量等于它前一个月的兔子数量加它前两个月的兔子数量，
# 即f(n)=f(n-1)+f(n-2)。假设第1个月的兔子有2只，第2个月的兔子有3只，
# 你能使用递归的方法求得第n个月的兔子有多少只吗？
# 输入描述：
# 输入正整数n，n<10。
# 输出描述：
# 输出第n个月的兔子数量。
# def num_robbet(n):
#     if n== 1:
#         return 2
#     if n==2:
#         return 3
#     return num_robbet(n-1)+num_robbet(n-2)
# import math
#
# rs=[1, 2, 4, 9, 10, 13]
#
# for r in rs:
#     print('%.2f'%(4*math.pi*pow(r,2)))
import re

#
# 描述
# 牛牛的Python老师为了更好地管理班级，利用一个类Student来管理学生，
# 这个类包含了学生姓名（str）、学号（str）、分数（int）、
# 每次作业等级（list[str]）等信息。请你帮助牛牛的老师实现这样一个类，
# 并定义构造方法实现初始化，定义打印函数实现打印学生的姓名、学号、分数、
# 提交作业的次数、每次作业的等级。
# 输入描述：
# 第一行输入字符串表示学生姓名。
# 第二行输入字符串表示学生学号。
# 第三行输入整数表示学生得分。
# 第四行输入多个大写字母表示每次作业等级，用空格间隔。
# 输出描述：
# 用一句话输出学生的姓名、学号、分数、提交作业的次数、每次作业的等级，可以参考输出样例。
#
# class Student:
#     def __init__(self,name,study_id,scores,home_work_list):
#         self.name=name
#         self.study_id=study_id
#         self.scores=scores
#         self.home_work_list=home_work_list
#         self.str_grade=" ".join(home_work_list)
#         print("{0}'s student number is {1}, and his grade is {2}. "
#               "He submitted {3} assignments, each with a grade of {4}".
#               format(self.name,self.study_id,self.scores,len(self.home_work_list),self.str_grade))
#
# name=str(input())
# study_id=str(input())
# scores=str(input())
# home_work_list=str(input()).split()
# student=Student(name,study_id,scores,home_work_list)

#
# 描述
# 请为牛客网的员工创建一个Employee类，包括属性有姓名（name）、（salary），并设置初始化。
# 同时该类包括一个方法printclass，用于输出类似'NiuNiu‘s salary is 4000, and his age is 22'的语句。
# 请根据输入的name与salary为该类创建实例e，并调用printclass方法输出信息，如果没有年龄信息则输出错误信息"Error! No age"。
# 根据输入的年龄为实例e直接添加属性age等于输入值，再次调用printclass方法输出信息。（printclass方法中建议使用try...except...结构）
# 输入描述：
# 三行分别输入姓名name、工资salary、年龄age，其中第一个为字符串，后两个为整型数字。
# 输出描述：
# 根据描述输出错误信息或是打印信息。
# class Employee:
#     def __init__(self,name,salary,age=None):
#         self.name = name
#         self.salary = salary
#         self.age = age
#         self.printclass()
#     def printclass(self):
#         if self.age==None:
#             print("Error! No age")
#             return
#         try:
#             print("{0}'salary is {1}, and his age is {2}".format(str(self.name),str(self.salary),str(self.age)))
#         except:
#             print("Error! No age")
#
#
# name=str(input())
# salary=str(input())
# employee=Employee(name,salary)
# age=str(input())
# employee2=Employee(name,salary,age)


# 描述
# 请创建一个Coordinate类表示坐标系，属性有x和y表示横纵坐标，
# .并为其创建初始化方法__init__。
# 请重载方法__str__为输出坐标'(x, y)'。
# 请重载方法__add__，更改Coordinate类的相加运算为横坐标与横坐标相加，纵坐标与纵坐标相加，返回结果也是Coordinate类。
# 现在输入两组横纵坐标x和y，请将其初始化为两个Coordinate类的实例c1和c2，并将坐标相加后输出结果。
# 输入描述：
# 第一行输入两个整数x1与y1，以空格间隔。
# 第二行输入两个整数x2与y2，以空格间隔。
# 输出描述：
# 输出相加后的坐标。

# class Coordinate:
#     def __init__(self, x, y):
#         self.x = x
#         self.y = y
#
#     def __str__(self):
#         return f'({self.x}, {self.y})'
#
#     def __add__(self, other):
#         if isinstance(other, Coordinate):
#             # 将两个Coordinate对象的横坐标和纵坐标相加
#             new_x = self.x + other.x
#             new_y = self.y + other.y
#             # 返回新的Coordinate对象
#             return Coordinate(new_x, new_y)
#         else:
#             # 如果相加的对象不是Coordinate类型，抛出异常
#             raise ValueError("Unsupported operand type. Must be Coordinate.")
#
#
# # 输入两组坐标
# x1, y1 = map(int, input().split())
# x2, y2 = map(int, input().split())
#
# # 初始化为Coordinate类的实例
# c1 = Coordinate(x1, y1)
# c2 = Coordinate(x2, y2)
#
# # 将坐标相加
# result = c1 + c2
#
# # 输出相加后的坐标
# print(result)
#
# python中的重载和重写的区别
#
# 在Python中，重载（overloading）和重写（overriding）是两个不同的概念，它们分别用于描述类中方法的不同特性。
#
# 重载（Overloading）：
#
# 定义： 重载是指在同一个类中，可以定义多个同名的方法，但这些方法的参数类型或个数必须不同。
# 示例：
# python
#
#
# class MyClass:
#     def add(self, x):
#         return x + 1
#
#     def add(self, x, y):
#         return x + y
#
#
# 这里，add
# 方法被重载了，分别有一个参数版本和两个参数版本。
# 重写（Overriding）：
#
# 定义： 重写是指子类重新定义了父类中已有的方法，使用相同的方法名和参数列表。
# 示例：
# python
#
#
# class Animal:
#     def speak(self):
#         print("Animal speaks")
#
#
# class Dog(Animal):
#     def speak(self):
#         print("Dog barks")
#
#
# 在这里，Dog
# 类重写了
# Animal
# 类的
# speak
# 方法，改变了该方法的实现。
# 总结：
#
# 重载关注于同一类中方法名相同但参数不同的情况，主要是为了提供更灵活的调用方式。
# 重写关注于子类重新定义了父类中已有的方法，以提供不同的实现。
# 需要注意的是，在Python中，方法的重载并不像一些其他语言那样严格，因为Python是一种动态类型语言，
# 它支持可变数量的参数和默认参数值，因此可以通过一个方法实现多种调用方式。然而，方法的重写在Python中是一种常见的用法。

# 牛牛最近正在研究网址，他发现好像很多网址的开头都是'https://www'，
# 他想知道任意一个网址都是这样开头吗。于是牛牛向你输入一个网址（字符串形式），
# 你能使用正则函数re.match在起始位置帮他匹配一下有多少位是相同的吗？（区分大小写）
# 输入描述：
# 输入一行字符串表示网址。
# 输出描述：
# 输出网址从开头匹配到第一位不匹配的范围。


# 牛牛翻看以前记录朋友信息的电话薄，电话号码几位数字之间使用-间隔，
# 后面还接了一下不太清楚什么意思的英文字母，
# 你能使用正则匹配re.sub将除了数字以外的其他字符去掉，提取一个全数字电话号码吗？
# 输入描述：
# 输入一行字符串，字符包括数字、大小写字母和-
# 输出描述：
# 输出该字符串提取后的全数字信息。
#
# re.sub() 函数用于在字符串中替换与正则表达式模式匹配的部分。它的基本语法如下：
#
# python
# re.sub(pattern, replacement, string, count=0, flags=0)
# pattern: 要匹配的正则表达式模式。
# replacement: 替换的字符串。
# string: 要进行替换的原始字符串。
# count: （可选）指定替换的最大次数，默认为 0，表示替换所有匹配项。
# flags: （可选）用于指定正则表达式的标志，例如 re.IGNORECASE 表示不区分大小写。
# 下面是一个简单的例子，演示如何使用 re.sub() 进行字符串替换：
#
# python
# import re
#
# text = "Hello, world! Hello, Python!"
#
# # 将所有的 "Hello" 替换为 "Hi"
# result = re.sub(r'Hello', 'Hi', text)
#
# print(result)
# 输出：
#
# Hi, world! Hi, Python!
# 如果要限制替换的次数，可以使用 count 参数：
#
# python
# result_with_limit = re.sub(r'Hello', 'Hi', text, count=1)
# print(result_with_limit)
# 输出：
#
# Hi, world! Hello, Python!
# 在上述示例中，只有第一个 "Hello" 被替换为 "Hi"，因为 count 参数被设置为 1。
#
# 需要注意的是，re.sub() 返回一个新的字符串，原始字符串并没有被修改。如果你希望修改原始字符串，你需要将返回值赋给原始字符串变量。

# import re
# phonenum=str(input()).replace("-","")
# patten=re.compile(r'\d+')
# phonenum=re.search(patten,phonenum)
# print(phonenum.group())
#
# 描述
# 牛牛记录电话号码时，习惯间隔几位就加一个-间隔，方便记忆，
# 同时他还会在电话后面接多条#引导的注释信息。拨打电话时，
# -可以被手机正常识别，#引导的注释信息就必须要去掉了，
# 你能使用正则匹配re.match将前面的数字及-信息提取出来吗，去掉后面的注释信息。
# 输入描述：
# 输入一行字符串，包括数字、大小写字母、#、-及空格。
# 输出描述：
# 输出提取的仅包含数字和-的电话号码。
import re
n = input()
res = re.match(r'(\d*[-]?)*',n)
print(res.group())